package generic;

import java.util.Arrays;

/**
 * 自定义泛型
 * class 类名<T, R> { //表示可以有多个泛型
 *     成员;
 * }
 */
public class CustomGeneric_ {

    public static void main(String[] args) {

        /*
            1.普通成员可以使用泛型(属性、方法)
            2.使用泛型的数组不能初始化
            3.静态方法中不能使用类的泛型
            4.泛型类的类型，是在创建对象时确定的(因为创建对象时需要指定类型)
            5.如果在创建对象时，没有指定类型，默认为Object
         */

        Tiger2<Double, String, Integer> g = new Tiger2<>("John");
        g.setT(10.9);
        //g.setT("yy");//错误，类型不对
        System.out.println(g);

        Tiger2<Object, Object, Object> g2 = new Tiger2<>("John");//ok T=Object R=Object M=Object
        g2.setT("yy");//可以，因为 String 是 Object子类
        System.out.println(g2);

    }
}

class Tiger2<T, R, M> {

    String name;

    //属性使用到泛型
    R r;

    M m;

    T t;

    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;

    public Tiger2(String name) {
        this.name = name;
    }

    //构造器使用泛型
    public Tiger2(String name, R r, M m, T t) {
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //方法使用到泛型
    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger2{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}
